home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / µSim 1.0.5 / source / InitMenus.c < prev    next >
Encoding:
Text File  |  1995-12-06  |  27.2 KB  |  1,004 lines  |  [TEXT/CWIE]
  1. /*
  2. Copyright © 1993,1994,1995 Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware:
  5. you may copy, exchange, modify this code.
  6. You may include this code in any kind of application: freeware,
  7. shareware, or commercial, provided that full credits are given.
  8. You may not sell or distribute this code for profit.
  9. */
  10.  
  11. //#pragma load "MacDump"
  12.  
  13. #include    "UtilsSys7.h"
  14. #include    "CursorBalloon.h"
  15. #include    "FabACursors.h"
  16. #include    "FabWList.h"
  17. #include    "InitCursorBalloon.h"
  18. #include    "SoundHandling.h"
  19. #include    "Independents.h"
  20. #include    "Internet.h"
  21. #include    "FabLibResIDs.h"
  22.  
  23. #include    "Globals.h"
  24. #include    "AEHandlers.h"
  25. #include    "Animation.h"
  26. #include    "ControlStore.h"
  27. #include    "Disasm.h"
  28. #include    "DoEditDialog.h"
  29. #include    "DoMenu.h"
  30. #include    "DragManSim.h"
  31. #include    "Dump.h"
  32. #include    "InitMenus.h"
  33. #include    "Input.h"
  34. #include    "Main.h"
  35. #include    "Microprogram_Ed.h"
  36. #include    "Registers.h"
  37. #include    "SimAsm.h"
  38. #include    "SimUtils.h"
  39.  
  40. #if defined(FabSystem7orlater)
  41.  
  42. #pragma segment Main
  43.  
  44. static AEEventHandlerUPP    gmyHandleIO_UPP, gmyHandleGenericAlert_UPP;
  45.  
  46. #pragma segment Init
  47.  
  48. enum {
  49. kREGFONT = 128
  50. };
  51.  
  52. enum winds {
  53. kWIND_Microprogram_Ed = 256,
  54. kWIND_Animation,
  55. kWIND_IO,
  56. kWIND_Registers,
  57. kWIND_Dump,
  58. kWIND_Disasm
  59. };
  60.  
  61. static void Init_My_Menus(void);
  62. static void GestaltCheck(void);
  63. static OSErr Init_Microprogram_Ed(void);
  64. static OSErr Init_Animation(void);
  65. static OSErr Init_Registers(void);
  66. static OSErr Init_Disasm(void);
  67. static Boolean InitPrefs(void);
  68. static Boolean    GetFontNumber(ConstStr255Param fontName, short *fontNum);
  69. static ListHandle MakeList(RectPtr theListRect, WindowPtr theWindow, short lines);
  70. static TEHandle MakeTE(RectPtr Position);
  71. static OSErr InitIO(void);
  72. static OSErr InitDump(void);
  73. static void FatalErrorAlert(short alertID, OSErr reason);
  74.  
  75. /* Init_My_Menus: sets up the menu bar */
  76.  
  77. static void Init_My_Menus(void)
  78. {
  79.     {
  80.     register Handle menuBar;
  81.     
  82.     SetMenuBar(menuBar = GetNewMBar(kRes_Menu_Apple));
  83.     DisposeHandle(menuBar);
  84.     }
  85.  
  86. AppendResMenu(gMenu_Apple = GetMenuHandle(kRes_Menu_Apple),'DRVR');
  87. gMenu_File = GetMenuHandle(kRes_Menu_File);
  88. gMenu_Edit = GetMenuHandle(kRes_Menu_Edit);
  89. gMenu_Windows = GetMenuHandle(kRes_Menu_Windows);
  90. gMenu_Control = GetMenuHandle(kRes_Menu_Control);
  91. gMenu_Assembler = GetMenuHandle(kRes_Menu_Assembler);
  92. InsertMenu(GetMenu(kRes_Menu_HMemory), hierMenu);
  93. InsertMenu(GetMenu(kRes_Menu_HRegs), hierMenu);
  94. InsertMenu(GetMenu(kRes_Menu_HDisasm), hierMenu);
  95. InsertMenu(GetMenu(kRes_Menu_HDump), hierMenu);
  96. InsertMenu(GetMenu(kMENU_HCopyWebLocation), hierMenu);
  97. InsertMenu(GetMenu(kMENU_HVisitWebLocation), hierMenu);
  98. gPopMenu = GetMenu(kRes_Menu_PopDump);
  99. //DrawMenuBar();
  100. }
  101.  
  102. /* InitAll: initializes the whole environment */
  103.  
  104. void InitAll(void)
  105. {
  106. EventRecord    dummyEvent;
  107. long    timingInfo;
  108. Rect    startingRect, endingRect;
  109. Point    dummyPt = {0, 0};
  110. DialogPtr    agh;
  111. register Handle    splash;
  112. register OSErr    err;
  113. register Boolean    prefsFileWasAbsent;
  114.  
  115. timingInfo = TickCount();
  116.  
  117. gMyGrowZoneUPP = NewGrowZoneProc(MyGrowZone);
  118. SetGrowZone(gMyGrowZoneUPP);
  119. MoreMasters();
  120. MoreMasters();
  121. MoreMasters();
  122. MoreMasters();
  123. MoreMasters();
  124. MoreMasters();
  125. InitGraf(&qd.thePort);
  126. InitFonts();
  127. InitWindows();
  128. InitMenus();
  129. TEInit();
  130. InitDialogs(nil);
  131.  
  132. FlushEvents(everyEvent, 0);
  133. InitCursor();
  134.  
  135. (void)UnloadScrap();
  136.  
  137. GestaltCheck();
  138.  
  139. gWatchHandle = GetCursor(watchCursor);
  140. SetCursor(*gWatchHandle);
  141. (void) FabLoadCursors(128);
  142.  
  143. InitMySoundHandling();
  144.  
  145. gInstrClikLoopUPP = MyNewListClickLoopProc(instrClikLoop);
  146. gCommentClikLoopUPP = MyNewListClickLoopProc(commentClikLoop);
  147. gSwitchCursClikLoopUPP = MyNewListClickLoopProc(switchCursClikLoop);
  148.  
  149. (void)InitCursorBalloonManager();
  150.  
  151. splash = OpenSplash(&agh, nil);
  152. SetGrafPortOfDialog(agh);
  153. endingRect = agh->portRect;
  154. LocalToGlobal(&topLeft(endingRect));
  155. LocalToGlobal(&botRight(endingRect));
  156. startingRect = endingRect;
  157. InsetRect(&startingRect, ((endingRect.right - endingRect.left) >> 1) - 2,
  158.             ((endingRect.bottom - endingRect.top) >> 1) - 2);
  159.  
  160. FabRotateCursor();
  161. timingInfo = TickCount() - timingInfo;
  162. if (timingInfo >= 28)    /* unusually slow machine */
  163.     gZoomFactor = 4;
  164. else if (timingInfo >= 17)    /* Plus, SE, Classic Mac */
  165.     gZoomFactor = 5;
  166. else if (timingInfo >= 10)
  167.     gZoomFactor = 6;
  168. else if (timingInfo >= 4)    /* Quadra class Mac */
  169.     gZoomFactor = 7;
  170. else if (timingInfo >= 2)
  171.     gZoomFactor = 8;
  172. else    /* super-duper (RISC?) Macintosh */
  173.     gZoomFactor = 9;
  174.  
  175. ZoomRectToRectAutoGrafPort(&startingRect, &endingRect, gZoomFactor);
  176. ShowWindow(agh);
  177. DrawDialog(agh);
  178.  
  179. gIBeamHandle = GetCursor(iBeamCursor);
  180. gPlusHandle = GetCursor(plusCursor);
  181.  
  182. FabRotateCursor();
  183.  
  184. gMMemory = NewPtrClear(kSIZE_RAM);
  185. gCsMemory = (union u_mir *)NewPtrClear(kSIZE_ASSMEM + kSIZE_CSMEM);
  186. if (gCsMemory)
  187.     gAssMemory = (((Ptr)gCsMemory) + kSIZE_CSMEM);
  188.  
  189. MyFillBuffer((long *)gAssMemory, numOfLongs(kSIZE_ASSMEM), 0x03030303);
  190.  
  191. FabRotateCursor();
  192.  
  193. Init_My_Menus();
  194.  
  195. gRegs[kREG_ZERO] = 0;
  196. gRegs[kREG_ONE] = 1;
  197. gRegs[kREG_MINUS1] = -1;
  198.  
  199. FabRotateCursor();
  200.  
  201. prefsFileWasAbsent = InitPrefs();
  202.  
  203. FabRotateCursor();
  204.  
  205. ResetMemory();
  206. ResetRegisters();
  207. UnloadSeg(ResetRegisters);
  208.  
  209. FabRotateCursor();
  210.  
  211. if (Init_Animation()) ExitToShell();
  212.  
  213. FabRotateCursor();
  214.  
  215. if (Init_Microprogram_Ed()) ExitToShell();
  216.  
  217. FabRotateCursor();
  218.  
  219. if (Init_Registers()) ExitToShell();
  220.  
  221. FabRotateCursor();
  222.  
  223. if (InitIO()) ExitToShell();
  224.  
  225. FabRotateCursor();
  226.  
  227. if (InitDump()) ExitToShell();
  228.  
  229. FabRotateCursor();
  230.  
  231. if (Init_Disasm()) ExitToShell();
  232.  
  233. FabRotateCursor();
  234.  
  235. SetMir(-1L);
  236. SetMir(0L);
  237.  
  238. if (prefsFileWasAbsent)
  239.     gPrefs.remembWind = true;
  240.  
  241. if(err = InstallRequiredAEHandlers(myHandleOAPP, myHandleODOC, myHandlePDOC, myHandleQUIT)) {
  242.     FatalErrorAlert(kALRT_GENERICERROR, err);
  243.     gDoneFlag = true;
  244.     }
  245.  
  246. FabRotateCursor();
  247.  
  248. gmyHandleIO_UPP = NewAEEventHandlerProc(myHandleIO);
  249. gmyHandleGenericAlert_UPP = NewAEEventHandlerProc(myHandleGenericAlert);
  250. if(err = AEInstallEventHandler(kFCR_MINE, kAEmySignalIO, gmyHandleIO_UPP, 0, false)) {
  251.     FatalErrorAlert(kALRT_GENERICERROR, err);
  252.     gDoneFlag = true;
  253.     }
  254.  
  255. if(err = AEInstallEventHandler(kCreat, kAEAlert, gmyHandleGenericAlert_UPP, 0, false)) {
  256.     FatalErrorAlert(kALRT_GENERICERROR, err);
  257.     gDoneFlag = true;
  258.     }
  259.  
  260. (void)TEFromScrap();
  261.  
  262. FabRotateCursor();
  263.  
  264. gICerr = MyICInit(&gICinst, kFCR_MINE);
  265.  
  266. FabRotateCursor();
  267.  
  268. DisposeSplash(splash, agh);
  269. UnloadSeg(DisposeSplash);
  270.  
  271. FabRotateCursor();
  272.  
  273. (void) EventAvail(0, &dummyEvent);
  274.  
  275. FabRotateCursor();
  276.  
  277. if (gPrefs.AnimVisible)
  278.     ShowWindowAndCheckMenu(gWPtr_Animation, kMItem_Animation);
  279. if (gPrefs.DisasmVisible) {
  280.     DecideActivation(&dummyEvent, gWPtr_Disasm, dummyPt, false);
  281.     ShowWindowAndCheckMenu(gWPtr_Disasm, kMItem_Disasm);
  282.     }
  283. if (gPrefs.DumpVisible) {
  284.     DecideActivation(&dummyEvent, gWPtr_Dump, dummyPt, false);
  285.     ShowWindowAndCheckMenu(gWPtr_Dump, kMItem_Dump);
  286.     }
  287. if (gPrefs.IOVisible) {
  288.     DecideActivation(&dummyEvent, gWPtr_IO, dummyPt, false);
  289.     ShowWindowAndCheckMenu(gWPtr_IO, kMItem_IO);
  290.     }
  291. if (gPrefs.RegsVisible)
  292.     ShowWindowAndCheckMenu(gWPtr_Registers, kMItem_Registers);
  293.  
  294. gILCBase = gRegs[kREG_PC];
  295.  
  296. FabRotateCursor();
  297.  
  298. AdjustMenus(nil);
  299. DrawMenuBar();
  300. FabFreeCursors();
  301. InitCursor();
  302. }
  303.  
  304. /* GestaltCheck: is this Mac set up with all we need to run? */
  305.  
  306. static void GestaltCheck(void)
  307. {
  308. #define    POWERMANAGER    ((1L << gestaltPMgrExists)|(1L << gestaltPMgrCPUIdle))
  309. #define TEMPMEMMANAGER    ((1L << gestaltTempMemSupport)|(1L << gestaltRealTempMemory)|(1L << gestaltTempMemTracked))
  310. long    Gresp;
  311.  
  312. if (TrapAvailable(_Gestalt)) {
  313.     if (Gestalt(gestaltDragMgrAttr, &Gresp) == noErr)
  314.         gDragManagerActive = Gresp & (1L << gestaltDragMgrPresent);
  315.     if (Gestalt(gestaltQuickdrawVersion, &Gresp) == noErr)
  316.         gHasColorQD = ((Byte)(Gresp >> 8)) > 0;
  317.     if (Gestalt(gestaltPowerMgrAttr, &Gresp) == noErr)
  318.         gPwrManagerIsPresent = ((Gresp & POWERMANAGER) == POWERMANAGER) != 0;
  319.     if (Gestalt(gestaltAliasMgrAttr, &Gresp) == noErr)
  320.         if (Gresp & (1L << gestaltAliasMgrPresent))
  321.             if (Gestalt(gestaltAppleEventsAttr, &Gresp) == noErr)
  322.                 if (Gresp & (1L << gestaltAppleEventsPresent))
  323.                     if (Gestalt(gestaltDITLExtAttr, &Gresp) == noErr)
  324.                         if (Gresp & (1L << gestaltDITLExtPresent))
  325.                             if (Gestalt(gestaltFindFolderAttr, &Gresp) == noErr)
  326.                                 if (Gresp & (1L << gestaltFindFolderPresent))
  327.                             if (Gestalt(gestaltFSAttr, &Gresp) == noErr)
  328.                                 if (Gresp & (1L << gestaltHasFSSpecCalls))
  329.                             if (Gestalt(gestaltHelpMgrAttr, &Gresp) == noErr)
  330.                                 if (Gresp & (1L << gestaltHelpMgrPresent))
  331.                             if (Gestalt(gestaltPopupAttr, &Gresp) == noErr)
  332.                                 if (Gresp & (1L << gestaltPopupPresent))
  333.                     //        if (Gestalt(gestaltResourceMgrAttr, &Gresp) == noErr)
  334.                     //            if (Gresp & (1L << gestaltPartialRsrcs))
  335.                             if (Gestalt(gestaltStandardFileAttr, &Gresp) == noErr)
  336.                                 if (Gresp & (1L << gestaltStandardFile58))
  337.                             if (Gestalt(gestaltTextEditVersion, &Gresp) == noErr)
  338.                                 if (Gresp >= gestaltTE4)
  339.                             if (Gestalt(gestaltOSAttr, &Gresp) == noErr)
  340.                                 if ((Gresp & TEMPMEMMANAGER) == TEMPMEMMANAGER)
  341.                             /* proceed because everything is OK */
  342.                                 return;
  343.     }
  344. (void)StopAlert_UPP(kALRT_OLDSYSTEM, nil);
  345. ExitToShell();
  346. }
  347.  
  348. /* Init_Microprogram_Ed: initializes the Microprogram window */
  349.  
  350. static OSErr Init_Microprogram_Ed(void)
  351. {
  352. enum {
  353. kR_RECTS = 128
  354. };
  355.  
  356. FabWindowPtr    thefabw;
  357. Handle    tempSH;
  358. ControlHandle *ControlScan;
  359. RgnHandle    theRgn;
  360. WindowPtr    w;
  361. Rect    tempRect;
  362. Point tempCell;
  363. short i;
  364. OSErr    err = appMemFullErr;
  365.  
  366. tempCell.h = 0;
  367.     {
  368.     register RectPtr    RectScan, *keyRScan;
  369.     register short    numrects;
  370.     short *numrectsPtr;
  371.  
  372.     RectScan = (RectPtr)((numrectsPtr = (short *)*Get1Resource('nrct', kR_RECTS)) + 1);
  373.     for (numrects = *numrectsPtr, keyRScan = keyrects, i = 0; i < numrects; i++)
  374.         *keyRScan++ = RectScan++;
  375.     }
  376. maxLLine[kL_COMMENTS] = 127;
  377. tempSH = Get1Resource(krInstructions, kOPCODES);
  378. maxLLine[kL_INSTR] = *(unsigned short *)*tempSH;
  379. gWPtr_Microprogram_Ed = w = GetNewWindow(kWIND_Microprogram_Ed, nil, (WindowPtr)-1L);
  380. if (w) {
  381.     SetPortWindowPort(w);
  382.     if (gPrefs.remembWind)
  383.         if (IsOnScreenWeak(gPrefs.MProgTopLeft))
  384.             MoveWindow(w, gPrefs.MProgTopLeft.h, gPrefs.MProgTopLeft.v, false);
  385.     TextFont(geneva);
  386.     TextSize(9);
  387.     for( ControlScan = &controls[kNUM_CONTROLS], i = kRES_CNTL+kNUM_CONTROLS-1;
  388.         i >= kRES_CNTL; i-- )
  389.         *--ControlScan = GetNewControl(i, w);
  390.     Lists[kL_COMMENTS] = MakeList(keyrects[kKEY_LIST], w,
  391.                                     maxLLine[kL_COMMENTS]+1);
  392.     (*Lists[kL_COMMENTS])->lClickLoop = gCommentClikLoopUPP;
  393.     Lists[kL_INSTR] = MakeList(keyrects[kKEY_INSTR], w,
  394.                                 maxLLine[kL_INSTR]+1);
  395.     (*Lists[kL_INSTR])->lClickLoop = gInstrClikLoopUPP;
  396.     TextFont(systemFont);
  397.     TextSize(12);
  398.     TEs[kKEY_COMMENT] = MakeTE(keyrects[kKEY_COMMENT]);
  399.     (void)TEFeatureFlag(teFOutlineHilite, teBitSet, TEs[kKEY_COMMENT]);
  400.     TEs[kKEY_BRTO] = MakeTE(keyrects[kKEY_BRTO]);
  401.     (void)TEFeatureFlag(teFOutlineHilite, teBitSet, TEs[kKEY_BRTO]);
  402.     TextFont(geneva);
  403.     TextSize(9);
  404.         {
  405.         register ROpcodePtr    instrScan;
  406.         register SignedByte    savedState;
  407.     
  408.         savedState = WantThisHandleSafe(tempSH);
  409.         instrScan = (ROpcodePtr)(((short *)(*tempSH))+1);
  410.         for ( i = 0; i <= maxLLine[kL_INSTR]; i++, instrScan++) {
  411.             tempCell.v = i;
  412.             LSetCell(instrScan, 4, tempCell, Lists[kL_INSTR]);
  413.             }
  414.         HSetState(tempSH, savedState);
  415.         }
  416.     ResetMicroprogramWindow();
  417.     UnloadSeg(ResetMicroprogramWindow);
  418.  
  419. //    InitFabWindow((FabWindowPtr)w);
  420.     thefabw = AddWindowToList(w);
  421.     SetActivate(thefabw, Activate_Microprogram_Ed);
  422.     SetUpdate(thefabw, Update_Microprogram_Ed);
  423.     SetGoAway(thefabw, CloseMicroProg);
  424.     SetContent(thefabw, Do_Microprogram_Ed);
  425.  
  426.     for (i = kKEY_BRTO; i <= kKEY_INSTR; i++) {
  427.         theRgn = NewRgn();
  428.         tempRect = *keyrects[i];
  429.         if (i > kKEY_COMMENT)
  430.             tempRect.right -= kScrollbarAdjust;
  431.         RectRgn(theRgn, &tempRect);
  432.         InstallRgnHandler(thefabw, theRgn, nil, i <= kKEY_COMMENT ? gIBeamHandle : gPlusHandle,
  433.                     toMenu(kBalloons_MPrg, i + kNUM_CONTROLS + 1), 0, 0);
  434.         }
  435.  
  436.     for (i = kPOPUP_ABUS; i <= kCHECK_ACTMAP; i++) {
  437.         theRgn = NewRgn();
  438.         RectRgn(theRgn, &(*controls[i])->contrlRect);
  439.         InstallRgnHandler(thefabw, theRgn, nil, nil,
  440.                     toMenu(kBalloons_MPrg, i + 1), 0, 0);
  441.         }
  442.  
  443. //    ResizeObjects(w);
  444.  
  445.     RecalcGlobalCoords(thefabw);
  446.  
  447.     err = noErr;
  448.     }
  449. return err;
  450. }
  451.  
  452. /* Init_Animation: initializes the Animation Window */
  453.  
  454. /* da schiaffare dentro la routine successiva */
  455. const short    initial[] = { kP_REGISTERS, kC_ALU2MSL1, kC_ALU2MSL2, kP_MIR, kP_TEXT, 0 };
  456.  
  457. static OSErr Init_Animation(void)
  458. {
  459. Rect    tempRect;
  460. BitMap    offBits;
  461. FabWindowPtr    thefabw;
  462. WindowPtr    w;
  463. PicHandle    tempPH;
  464. RgnHandle    theRgn;
  465. short    rightLong;
  466. short    count, i;
  467. OSErr    err = appMemFullErr;
  468.  
  469. gWPtr_Animation = w = GetNewWindow(kWIND_Animation, nil, (WindowPtr)-1L);
  470. if (w) {
  471.     SetPortWindowPort(w);
  472.     if (gPrefs.remembWind)
  473.         if (IsOnScreenWeak(gPrefs.AnimTopLeft))
  474.             MoveWindow(w, gPrefs.AnimTopLeft.h, gPrefs.AnimTopLeft.v, false);
  475.     ClipRect(&w->portRect);
  476.     offBits.bounds = w->portRect;
  477.     rightLong = ((offBits.bounds.right + 15) >> 4) << 1;
  478.     offBits.rowBytes = rightLong;
  479.     if (offScr = (GrafPtr)NewPtrClear(sizeof(GrafPort))) {
  480.         OpenPort(offScr);
  481.         if (offBits.baseAddr = NewPtrClear(rightLong * (long)offBits.bounds.bottom)) {
  482.             SetPortBits(&offBits);
  483.             TextFont(monaco);
  484.             ClipRect(&offBits.bounds);
  485.             PenPat(&qd.gray);
  486.             PenMode(notPatBic);
  487.             mirUpdRgn = NewRgn();
  488.                 {
  489.                 register RgnHandle tempRgn = NewRgn();
  490.                 register PicHandle *PictScan;
  491.                 register RectPtr    RectScan;
  492.             
  493.                 for(RectScan = rval, PictScan = images, count = kFIRST_PICT;
  494.                     count <= kLAST_PICT; count++) {
  495.                     register PicHandle tempPicH;
  496.                     
  497.                     tempPicH = GetPicture(count);
  498.                     *PictScan++ = tempPicH;
  499.                     tempRect = (*tempPicH)->picFrame;
  500.                     DrawPicture(tempPicH, &tempRect);
  501.                     RectRgn(tempRgn, &tempRect);
  502.                     PaintRgn(tempRgn);
  503.                     if( count <= kP_MPC ) {
  504.                         --tempRect.bottom;
  505.                         --tempRect.right;
  506.                         InsetRect(&tempRect, 3, 3);
  507.                         *RectScan++ = tempRect;
  508.                         }
  509.                     else if( count == kP_ALU ) {
  510.                         tempRect.bottom -= 4;
  511.                         tempRect.right -= 15;
  512.                         tempRect.left += 15;
  513.                         tempRect.top = tempRect.bottom - 15;
  514.                         *RectScan++ = tempRect;
  515.                         }
  516.                     else if( count == kP_MSL ) {
  517.                         tempRect.bottom -= 3;
  518.                         tempRect.top += 3;
  519.                         tempRect.right -= 3;
  520.                         tempRect.left += 19;
  521.                         *RectScan++ = tempRect;
  522.                         }
  523.                     else if( count == kP_MIR ) {
  524.                         register int    ind;
  525.             
  526.                         tempRect.bottom -= 2;
  527.                         ++tempRect.left;
  528.                         tempRect.top = tempRect.bottom - 15;
  529.                         tempRect.right = tempRect.left + 11;
  530.                         for( ind = 0; ind <= 12; ind++) {
  531.                             *RectScan++ = tempRect;
  532.                             RectRgn(tempRgn, &tempRect);
  533.                             UnionRgn(mirUpdRgn, tempRgn, mirUpdRgn);
  534.                             tempRect.left += 12;
  535.                             tempRect.right += 12;
  536.                             }
  537.                         tempRect.right += 11;
  538.                         *RectScan = tempRect;
  539.                         RectRgn(tempRgn, &tempRect);
  540.                         UnionRgn(mirUpdRgn, tempRgn, mirUpdRgn);
  541.                         }
  542.                     }
  543.                 DisposeRgn(tempRgn);
  544.                 }
  545.             ChangedAllBoxes();
  546.             ActivateObjs(initial);
  547.  
  548.         //    InitFabWindow((FabWindowPtr)w);
  549.             thefabw = AddWindowToList(w);
  550.             SetUpdate(thefabw, Update_Animation);
  551.             SetGoAway(thefabw, CloseAnimation);
  552.             SetContent(thefabw, Do_Animation);
  553.  
  554.             SetPortWindowPort(w);
  555.             for (i = kP_ALATCH - kFIRST_PICT; i <= kP_MAP - kFIRST_PICT; i++) {
  556.                 theRgn = NewRgn();
  557.                 tempPH = images[i];
  558.                 if (*tempPH == nil)
  559.                     LoadResource((Handle)tempPH);
  560.                 tempRect = (*tempPH)->picFrame;
  561.                 RectRgn(theRgn, &tempRect);
  562.                 InstallRgnHandler(thefabw, theRgn, nil, nil,
  563.                             toMenu(kBalloons_Anim, i + 1), 6, 0);
  564.                 }
  565.         
  566.         //    ResizeObjects(w);
  567.         
  568.             RecalcGlobalCoords(thefabw);
  569.  
  570.             err = noErr;
  571.             }
  572.         }
  573.     }
  574. return err;
  575. }
  576.  
  577. /* Init_Registers: initializes the Registers window */
  578.  
  579. static OSErr Init_Registers(void)
  580. {
  581. enum {
  582. kCNTL_BASE = 129
  583. };
  584.  
  585. Str255    tempS;
  586. FMetricRec    theMetrics;
  587. Rect    tempRect;
  588. FabWindowPtr    thefabw;
  589. WindowPtr    w;
  590. Handle    myStrHandle;
  591. RgnHandle    theRgn;
  592. Fixed    tempFixed;
  593. short    fontNumber, fontSize;
  594. short    theWidth, i;
  595. short    maxLength = 0;
  596. OSErr    err = appMemFullErr;
  597.  
  598. gWPtr_Registers = w = GetNewWindow(kWIND_Registers, nil, (WindowPtr)-1L);
  599. if (w) {
  600.     SetPortWindowPort(w);
  601.     if (gPrefs.remembWind)
  602.         if (IsOnScreenWeak(gPrefs.RegsTopLeft))
  603.             MoveWindow(w, gPrefs.RegsTopLeft.h, gPrefs.RegsTopLeft.v, false);
  604.     (void)WantThisHandleSafe(myStrHandle = Get1Resource('REGF', kREGFONT));
  605.     if (GetFontNumber((StringPtr)(*myStrHandle + 2), &fontNumber))
  606.         fontSize = *(short *)*myStrHandle;
  607.     else {
  608.         fontNumber = monaco;
  609.         fontSize = 9;
  610.         }
  611.     ReleaseResource(myStrHandle);
  612.     TextFont(fontNumber);
  613.     TextSize(fontSize);
  614.     if (Ctrl_Base = GetNewControl(kCNTL_BASE, w)) {
  615.         FontMetrics(&theMetrics);
  616.         tempFixed = theMetrics.descent + theMetrics.ascent + theMetrics.leading;
  617.  
  618.         tempFixed = mySwap(tempFixed);
  619.  
  620.         regLineHeight = (short)tempFixed;
  621.         
  622.         regDistFromTop = *(short *)&theMetrics.ascent + kREG_HORZSEPLINE;
  623.         HLock(myStrHandle = Get1Resource('STR#', kREG_NAMES));
  624.         for(i = 0; i < kDISP_REGS; i++) {
  625.             if (maxLength < (theWidth = StringWidth(GetPtrIndHString(myStrHandle, i))))
  626.                 maxLength = theWidth;
  627.             }
  628.         HUnlock(myStrHandle);
  629.         tempFixed = maxLength;
  630.         regVertSepLine = maxLength + kDIST_FROMLEFT + kDIST_FROMNAME;
  631.         
  632.         tempFixed = mySwap(tempFixed);
  633.         
  634.         maxLength = 0;
  635.             {
  636.             register Byte *myString;
  637.             register Byte    j, rememberedCh, stopAt;
  638.             SignedByte    savedState;
  639.         
  640.             savedState = WantThisHandleSafe(myStrHandle = (Handle)GetString(kSTR_BINALLOWED));
  641.             myString = (Byte *)*myStrHandle;
  642.             for (stopAt = *myString++, j = 0; j < stopAt; j++)
  643.                 if (maxLength < (theWidth = CharWidth(*myString++))) {
  644.                     maxLength = theWidth;
  645.                     rememberedCh = *(myString - 1);
  646.                     }
  647.             HSetState(myStrHandle, savedState);
  648.             for (myString = (Byte *)&tempS, j = 0; j <= 15; j++)
  649.                 *myString++ = rememberedCh;
  650.             maxLength = TextWidth(&tempS, 0, 16);
  651.             }
  652.         
  653.         tempFixed += ((long)maxLength << 16) +
  654.             ((const long)(kDIST_FROMLEFT + kDIST_FROMNAME + kDIST_FROMVERTSEP)<< 16);
  655.         tempFixed = mySwap(tempFixed);
  656.         SizeWindow(w, (short)tempFixed + 2,
  657.                     REG_TOP + regLineHeight * kDISP_REGS, false);
  658.         SetControlValue(Ctrl_Base, gPrefs.remembWind ? gPrefs.RegsBase : kPOP_HEX);
  659.         oldChoice = GetControlValue(Ctrl_Base);
  660.  
  661.     //    InitFabWindow((FabWindowPtr)w);
  662.         thefabw = AddWindowToList(w);
  663.         SetUpdate(thefabw, Update_Registers);
  664.         SetGoAway(thefabw, CloseRegisters);
  665.         SetContent(thefabw, Do_Registers);
  666.         SetGetDragRect(thefabw, getDragRectRegs);
  667.  
  668.         theRgn = NewRgn();
  669.         tempRect = (*Ctrl_Base)->contrlRect;
  670.         RectRgn(theRgn, &tempRect);
  671.         InstallRgnHandler(thefabw, theRgn, nil, nil,
  672.                         toMenu(kBalloons_Regs, kBRegs_Base), 0, 0);
  673.  
  674.         tempRect.top = REG_TOP;
  675.         tempRect.left = PRCT_L(w);
  676.         tempRect.bottom = REG_TOP + regLineHeight;
  677.         tempRect.right = PRCT_R(w);
  678.         for (i = kBRegs_PC; i <= kBRegs_Lo8; i++) {
  679.             theRgn = NewRgn();
  680.             RectRgn(theRgn, &tempRect);
  681.             InstallRgnHandler(thefabw, theRgn, nil, nil,
  682.                             toMenu(kBalloons_Regs, i), 0, 0);
  683.             tempRect.top = tempRect.bottom;
  684.             tempRect.bottom += regLineHeight;
  685.             }
  686.  
  687.     //    ResizeObjects(w);
  688.     
  689.         RecalcGlobalCoords(thefabw);
  690.         if (gDragManagerActive)
  691.             (void) MyInstallHWindow(w);
  692.  
  693.         err = noErr;
  694.         }
  695.     }
  696. //SetFractEnable(false);
  697. return err;
  698. }
  699.  
  700. /* Init_Disasm: initializes the Disassembler window */
  701.  
  702. static OSErr Init_Disasm(void)
  703. {
  704. enum {
  705. rdisasmVScroll = 145
  706. };
  707.  
  708. FMetricRec    theMetrics;
  709. FabWindowPtr    thefabw;
  710. register Fixed    tempFix;
  711. register WindowPtr    window;
  712. register OSErr    err = appMemFullErr;
  713.  
  714. gWPtr_Disasm = window = GetNewWindow(kWIND_Disasm, nil, (WindowPtr)-1L);
  715. if (window) {
  716.     SetPortWindowPort(window);
  717.     if (gPrefs.remembWind)
  718.         if (IsOnScreenWeak(gPrefs.DisasmTopLeft))
  719.             MoveWindow(window, gPrefs.DisasmTopLeft.h, gPrefs.DisasmTopLeft.v, false);
  720.     if (disasmVScroll = GetNewControl(rdisasmVScroll, window)) {
  721.         TextFont(monaco);
  722.         TextSize(9);
  723.         TextMode(srcCopy);
  724.         FontMetrics(&theMetrics);
  725.         tempFix = theMetrics.descent + theMetrics.ascent + theMetrics.leading;
  726.         tempFix = mySwap(tempFix);
  727.         disasmLineHeight = (short)tempFix;
  728.         disasmFromTop = *(short *)&theMetrics.ascent;
  729.         disasmCWidMax = *(short *)&theMetrics.widMax;
  730.         tempFix = FixMul(theMetrics.widMax, kMaxCharsInOneDisasmLineFixed);
  731.         tempFix = mySwap(tempFix);
  732.         SizeWindow(window, (short)tempFix + kScrollbarWidth + kDIST_FROMLEFT,
  733.             gPrefs.remembWind ? gPrefs.DisasmHeight :
  734.                 ((PRCT_B(window) - PRCT_T(window)) / disasmLineHeight) * disasmLineHeight, false);
  735.         SetupVertScrollBar(window, disasmVScroll);
  736.         SetupDisasmCtlMax(disasmVScroll);
  737.         if (gPrefs.remembWind)
  738.             SetControlValue(disasmVScroll, gPrefs.DisasmScrollVal);
  739.  
  740.     //    InitFabWindow((FabWindowPtr)window);
  741.         thefabw = AddWindowToList(window);
  742.         SetActivate(thefabw, Activate_Disasm);
  743.         SetUpdate(thefabw, Update_Disasm);
  744.         SetGrow(thefabw, Grow_Disasm);
  745.         SetGoAway(thefabw, CloseDisasm);
  746.         SetContent(thefabw, Do_Disasm);
  747.         SetGetDragRect(thefabw, getDragRectDisasm);
  748.  
  749.         InstallRgnHandler(thefabw, NewRgn(), RecalcDump, nil,
  750.                 toMenu(kBalloons_Dump, kBDisasm_Contents), 0, 0);
  751.  
  752.         ResizeObjects(window);
  753.         RecalcGlobalCoords(thefabw);
  754.  
  755.         if (gDragManagerActive)
  756.             (void) MyInstallHWindow(window);
  757.         err = noErr;
  758.         }
  759.     }
  760. return err;
  761. }
  762.  
  763. /* InitPrefs: loads preferences if present */
  764.  
  765. Boolean InitPrefs(void)
  766. {
  767. ParamBlockRec    myPB;
  768. EventRecord    dummyEv;
  769. FSSpec    myFSS;
  770. register Handle    myStrHand, prefsBuffer;
  771. short    prefsFRefNum;
  772. Boolean    targetFolder, isAnAlias;
  773. register OSErr    err;
  774. register SignedByte    oldState;
  775. register Boolean    prefsFileAbsent = false;
  776.  
  777. oldState = WantThisHandleSafe(myStrHand = (Handle)GetString(kSTR_PREFSFILENAME));
  778. if ((err = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  779.             &myFSS.vRefNum, &myFSS.parID)) == noErr) {
  780.     err = FSMakeFSSpecCompat(myFSS.vRefNum, myFSS.parID, (ConstStr255Param)*myStrHand, &myFSS);
  781.     if (err == fnfErr)
  782.         prefsFileAbsent = true;
  783.     else if (err == noErr)
  784.         if ((err = ResolveAliasFile(&myFSS, true, &targetFolder, &isAnAlias)) == noErr)
  785.             if (targetFolder)
  786.                 err = paramErr;
  787.             else
  788.                 if ((err = FSpOpenDFCompat(&myFSS, fsRdPerm, &prefsFRefNum)) == noErr) {
  789.                     if (prefsBuffer = NewHandleGeneral(sizeof(struct myprefs))) {
  790.                         myPB.ioParam.ioCompletion = nil;
  791.                         myPB.ioParam.ioRefNum = prefsFRefNum;
  792.                         HLock(prefsBuffer);
  793.                         myPB.ioParam.ioBuffer = *prefsBuffer;
  794.                         myPB.ioParam.ioReqCount = sizeof(struct myprefs);
  795.                         myPB.ioParam.ioPosMode = fsFromStart | kNoCacheMask;
  796.                         myPB.ioParam.ioPosOffset = 0L;
  797.                         (void)PBReadAsync(&myPB);
  798.                         while (myPB.ioParam.ioResult > 0) {
  799.                             SystemTask();
  800.                             (void)EventAvail(everyEvent, &dummyEv);
  801.                             }
  802.                         if ((err = myPB.ioParam.ioResult) == noErr)
  803.                             if (((struct myprefs *)*prefsBuffer)->prefsVersion == kCurPrefsVersion)
  804.                                 gPrefs = *(struct myprefs *)*prefsBuffer;
  805.                         DisposeHandle(prefsBuffer);
  806.                         }
  807.                     (void)FSClose(prefsFRefNum);
  808.                     }
  809.     }
  810. HSetState(myStrHand, oldState);
  811.  
  812. return prefsFileAbsent;
  813. }
  814.  
  815. /* GetFontNumber: gets font number from font name */
  816.  
  817. static Boolean    GetFontNumber(ConstStr255Param fontName, short *fontNum)
  818. {
  819. Str255    systemFontName;
  820. register Boolean    retFlag;
  821.  
  822. GetFNum(fontName, fontNum);
  823. if ((retFlag = (*fontNum != 0)) == false) {
  824.     GetFontName(0, systemFontName);
  825.     retFlag = EqualString(fontName, systemFontName, false, false);
  826.     }
  827. return retFlag;
  828. }
  829.  
  830. /* MakeList: builds a list given a rectangle, the window, and
  831. the initial number of lines */
  832.  
  833. static ListHandle MakeList(RectPtr theListRect, WindowPtr theWindow, short lines)
  834. {
  835. Rect    dataBounds;
  836. Rect    tempRect;
  837. Point    cSize = { 0, 0 };
  838. register ListHandle    theList;
  839.  
  840. tempRect = *theListRect;
  841. tempRect.right -= kScrollbarAdjust;
  842. SetRect(&dataBounds, 0, 0, 1, lines);
  843. theList = LNew(&tempRect, &dataBounds, cSize, 0, theWindow, true, false, false, true);
  844. (*theList)->selFlags = lOnlyOne;
  845. LSetSelect(true, cSize, theList);
  846. LSetDrawingMode(true, theList);
  847. return theList;
  848. }
  849.  
  850. /* MakeTE: builds a TextEdit field, given the rectangle,
  851. in the current window */
  852.  
  853. static TEHandle MakeTE(RectPtr Position)
  854. {
  855. Rect    tempRect;
  856.  
  857. tempRect = *Position;
  858. FrameRect(Position);
  859. InsetRect(&tempRect, 3, 3);
  860. return(TENew(&tempRect, &tempRect));
  861. }
  862.  
  863. /* InitIO: initializes the input/output window */
  864.  
  865. static OSErr InitIO(void)
  866. {
  867. enum {
  868. rVScroll = 142,        /* vertical scrollbar control */
  869. rHScroll            /* horizontal scrollbar control */
  870. };
  871.  
  872. Rect    destRect, viewRect;
  873. FabWindowPtr    thefabw;
  874. register WindowPtr    window;
  875. register DocumentIOPeek doc;
  876. register OSErr    err = appMemFullErr;
  877.  
  878. gWPtr_IO = window = GetNewWindow(kWIND_IO, nil, (WindowPtr)-1L);
  879. if (window) {
  880.     SetPortWindowPort(window);
  881.     
  882.     if (gPrefs.remembWind) {
  883.         if (IsOnScreen(&gPrefs.IOUserState)) {
  884.             (*(WStateDataHandle)((WindowPeek)window)->dataHandle)->userState = gPrefs.IOUserState;
  885.             ZoomWindow(window, inZoomIn, false);
  886.             }
  887.         }
  888.     doc = &gIODoc;
  889.     GetTERect(window, &viewRect);
  890.     destRect = viewRect;
  891.     destRect.right = destRect.left +
  892.                         (qd.screenBits.bounds.right - qd.screenBits.bounds.left);
  893.     if ( doc->docTE = TENew(&destRect, &viewRect) ) {
  894.         (void)TEFeatureFlag(teFOutlineHilite, teBitSet, doc->docTE);
  895.         TEAutoView(true, doc->docTE);
  896.         if (doc->docVScroll = GetNewControl(rVScroll, window)) {
  897.             if (doc->docHScroll = GetNewControl(rHScroll, window)) {
  898.     /* adjust & draw the controls, draw the window */
  899.                 AdjustScrollbars(window, true);
  900.  
  901.             //    InitFabWindow((FabWindowPtr)window);
  902.                 thefabw = AddWindowToList(window);
  903.                 doc->docWindow = thefabw;
  904.                 SetActivate(thefabw, DoActivateWindow);
  905.                 SetUpdate(thefabw, DoUpdateWindow);
  906.                 SetGrow(thefabw, DoGrowWindow);
  907.                 SetZoom(thefabw, DoZoomWindow);
  908.                 SetGoAway(thefabw, CloseIO);
  909.                 SetContent(thefabw, DoContentClick);
  910.                 
  911.                 InstallRgnHandler(thefabw, NewRgn(), RecalcIO, gIBeamHandle,
  912.                         toMenu(kBalloons_Dump, kBIO_Contents), 0, 0);
  913.                 ResizeObjects(window);
  914.                 RecalcGlobalCoords(thefabw);
  915.  
  916. //                InstallTrackingHandler(MyTrackingHandler, window, (void *) window);
  917. //                InstallReceiveHandler(MyReceiveDropHandler, window, (void *) window);
  918.                 err = noErr;
  919.                 }
  920.             }
  921.         }
  922.     }
  923. return err;
  924. } /* InitIO */
  925.  
  926. /* InitDump: initializes the Dump window */
  927.  
  928. static OSErr InitDump(void)
  929. {
  930. enum {
  931. krdmpVScroll = 144,    /* vertical scrollbar control */
  932. kCharsInOneLine = 0x002D0000
  933. };
  934.  
  935. FMetricRec    theMetrics;
  936. FabWindowPtr    thefabw;
  937. register Fixed    tempFix;
  938. register WindowPtr    window;
  939. register OSErr    err = appMemFullErr;
  940.  
  941. gWPtr_Dump = window = GetNewWindow(kWIND_Dump, nil, (WindowPtr)-1L);
  942. if (window) {
  943.     SetPortWindowPort(window);
  944.     if (gPrefs.remembWind)
  945.         if (IsOnScreenWeak(gPrefs.DumpTopLeft))
  946.             MoveWindow(window, gPrefs.DumpTopLeft.h, gPrefs.DumpTopLeft.v, false);
  947.     if (dumpVScroll = GetNewControl(krdmpVScroll, window)) {
  948.         TextFont(monaco);
  949.         TextSize(9);
  950.         TextMode(srcCopy);
  951.         FontMetrics(&theMetrics);
  952.         tempFix = theMetrics.descent + theMetrics.ascent + theMetrics.leading;
  953.         tempFix = mySwap(tempFix);
  954.         dumpLineHeight = (short)tempFix;
  955.         dumpFromTop = *(short *)&theMetrics.ascent;
  956.         dumpCWidMax = *(short *)&theMetrics.widMax;
  957.         tempFix = FixMul(theMetrics.widMax, kCharsInOneLine);
  958.         tempFix = mySwap(tempFix);
  959.         SizeWindow(window, (short)tempFix + kScrollbarWidth + kDIST_FROMLEFT,
  960.             gPrefs.remembWind ? gPrefs.DumpHeight :
  961.                 ((PRCT_B(window) - PRCT_T(window)) / dumpLineHeight) * dumpLineHeight,
  962.             false);
  963.         SetupVertScrollBar(window, dumpVScroll);
  964.         SetupDumpCtlMax(dumpVScroll);
  965.         if (gPrefs.remembWind)
  966.             SetControlValue(dumpVScroll, gPrefs.DumpScrollVal);
  967.  
  968.     //    InitFabWindow((FabWindowPtr)window);
  969.         thefabw = AddWindowToList(window);
  970.         SetActivate(thefabw, Activate_Dump);
  971.         SetUpdate(thefabw, Update_Dump);
  972.         SetGrow(thefabw, Grow_Dump);
  973.         SetGoAway(thefabw, CloseDump);
  974.         SetContent(thefabw, Do_Dump);
  975.         SetGetDragRect(thefabw, getDragRectDump);
  976.  
  977.         InstallRgnHandler(thefabw, NewRgn(), RecalcDump, nil,
  978.                 toMenu(kBalloons_Dump, kBDump_Contents), 0, 0);
  979.  
  980.         ResizeObjects(window);
  981.         RecalcGlobalCoords(thefabw);
  982.  
  983.         if (gDragManagerActive)
  984.             (void) MyInstallHWindow(window);
  985.         err = noErr;
  986.         }
  987.     }
  988. return err;
  989. } /* InitDump */
  990.  
  991. /* FatalErrorAlert: errors while initing windows */
  992.  
  993. static void FatalErrorAlert(short alertID, OSErr reason)
  994. {
  995. Str255    tempS;
  996.  
  997. MyNumToString(reason, tempS);
  998. ParamText(tempS, nil, nil, nil);
  999. (void)StopAlert_UPP(alertID, nil);
  1000. }
  1001.  
  1002. #endif
  1003.  
  1004.